home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / sdeparam.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  9.8 KB  |  318 lines
  1. /* Copyright (C) 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: sdeparam.c,v 1.2 2000/09/19 19:00:49 lpd Exp $ */
  20. /* DCTEncode filter parameter setting and reading */
  21. #include "memory_.h"
  22. #include "jpeglib_.h"
  23. #include "gserror.h"
  24. #include "gserrors.h"
  25. #include "gstypes.h"
  26. #include "gsmemory.h"
  27. #include "gsparam.h"
  28. #include "strimpl.h"        /* sdct.h requires this */
  29. #include "sdct.h"
  30. #include "sdcparam.h"
  31. #include "sjpeg.h"
  32.  
  33. /* Define a structure for the DCTEncode scalar parameters. */
  34. typedef struct dcte_scalars_s {
  35.     int Columns;
  36.     int Rows;
  37.     int Colors;
  38.     gs_param_string Markers;
  39.     bool NoMarker;
  40.     int Resync;
  41.     int Blend;
  42. } dcte_scalars_t;
  43. private const dcte_scalars_t dcte_scalars_default =
  44. {
  45.     0, 0, -1,
  46.     {0, 0}, 0 /*false */ , 0, 0
  47. };
  48. private const gs_param_item_t s_DCTE_param_items[] =
  49. {
  50. #define dctp(key, type, memb) { key, type, offset_of(dcte_scalars_t, memb) }
  51.     dctp("Columns", gs_param_type_int, Columns),
  52.     dctp("Rows", gs_param_type_int, Rows),
  53.     dctp("Colors", gs_param_type_int, Colors),
  54.     dctp("Marker", gs_param_type_string, Markers),
  55.     dctp("NoMarker", gs_param_type_bool, NoMarker),
  56.     dctp("Resync", gs_param_type_int, Resync),
  57.     dctp("Blend", gs_param_type_int, Blend),
  58. #undef dctp
  59.     gs_param_item_end
  60. };
  61.  
  62. /* ================ Get parameters ================ */
  63.  
  64. stream_state_proc_get_params(s_DCTE_get_params, stream_DCT_state);    /* check */
  65.  
  66. /* Get a set of sampling values. */
  67. private int
  68. dcte_get_samples(gs_param_list * plist, gs_param_name key, int num_colors,
  69.  const jpeg_compress_data * jcdp, gs_memory_t * mem, bool is_vert, bool all)
  70. {
  71.     const jpeg_component_info *comp_info = jcdp->cinfo.comp_info;
  72.     int samples[4];
  73.     bool write = all;
  74.     int i;
  75.  
  76.     for (i = 0; i < num_colors; ++i)
  77.     write |= (samples[i] = (is_vert ? comp_info[i].v_samp_factor :
  78.                 comp_info[i].h_samp_factor)) != 1;
  79.     if (write) {
  80.     int *data = (int *)gs_alloc_byte_array(mem, num_colors, sizeof(int),
  81.                            "dcte_get_samples");
  82.     gs_param_int_array sa;
  83.  
  84.     if (data == 0)
  85.         return_error(gs_error_VMerror);
  86.     sa.data = data;
  87.     sa.size = num_colors;
  88.     sa.persistent = true;
  89.     memcpy(data, samples, num_colors * sizeof(samples[0]));
  90.     return param_write_int_array(plist, key, &sa);
  91.     }
  92.     return 0;
  93. }
  94.  
  95. int
  96. s_DCTE_get_params(gs_param_list * plist, const stream_DCT_state * ss, bool all)
  97. {
  98.     gs_memory_t *mem = ss->memory;
  99.     stream_DCT_state dcts_defaults;
  100.     const stream_DCT_state *defaults = 0;
  101.     dcte_scalars_t params;
  102.     const jpeg_compress_data *jcdp = ss->data.compress;
  103.     int code;
  104.  
  105.     if (!all) {
  106.     jpeg_compress_data *jcdp_default =
  107.     (jpeg_compress_data *)
  108.     gs_alloc_bytes_immovable(mem, sizeof(*jcdp), "s_DCTE_get_params");
  109.  
  110.     if (jcdp_default == 0)
  111.         return_error(gs_error_VMerror);
  112.     defaults = &dcts_defaults;
  113.     (*s_DCTE_template.set_defaults) ((stream_state *) & dcts_defaults);
  114.     dcts_defaults.data.compress = jcdp_default;
  115.     jcdp_default->memory = dcts_defaults.jpeg_memory = mem;
  116.     if ((code = gs_jpeg_create_compress(&dcts_defaults)) < 0)
  117.         goto fail;        /* correct to do jpeg_destroy here */
  118. /****** SET DEFAULTS HERE ******/
  119.     dcts_defaults.data.common->Picky = 0;
  120.     dcts_defaults.data.common->Relax = 0;
  121.     }
  122.     params.Columns = jcdp->cinfo.image_width;
  123.     params.Rows = jcdp->cinfo.image_height;
  124.     params.Colors = jcdp->cinfo.input_components;
  125.     params.Markers.data = ss->Markers.data;
  126.     params.Markers.size = ss->Markers.size;
  127.     params.Markers.persistent = false;
  128.     params.NoMarker = ss->NoMarker;
  129.     params.Resync = jcdp->cinfo.restart_interval;
  130.     /* What about Blend?? */
  131.     if ((code = s_DCT_get_params(plist, ss, defaults)) < 0 ||
  132.     (code = gs_param_write_items(plist, ¶ms,
  133.                      &dcte_scalars_default,
  134.                      s_DCTE_param_items)) < 0 ||
  135.     (code = dcte_get_samples(plist, "HSamples", params.Colors,
  136.                  jcdp, mem, false, all)) < 0 ||
  137.     (code = dcte_get_samples(plist, "VSamples", params.Colors,
  138.                  jcdp, mem, true, all)) < 0 ||
  139.     (code = s_DCT_get_quantization_tables(plist, ss, defaults, true)) < 0 ||
  140.     (code = s_DCT_get_huffman_tables(plist, ss, defaults, true)) < 0
  141.     )
  142.     DO_NOTHING;
  143. /****** NYI ******/
  144.   fail:if (defaults) {
  145.     gs_jpeg_destroy(&dcts_defaults);
  146.     gs_free_object(mem, dcts_defaults.data.compress,
  147.                "s_DCTE_get_params");
  148.     }
  149.     return code;
  150. }
  151.  
  152. /* ================ Put parameters ================ */
  153.  
  154. stream_state_proc_put_params(s_DCTE_put_params, stream_DCT_state);    /* check */
  155.  
  156. /* Put a set of sampling values. */
  157. private int
  158. dcte_put_samples(gs_param_list * plist, gs_param_name key, int num_colors,
  159.          jpeg_compress_data * jcdp, bool is_vert)
  160. {
  161.     int code;
  162.     int i;
  163.     jpeg_component_info *comp_info = jcdp->cinfo.comp_info;
  164.     UINT8 samples[4];
  165.  
  166.     /*
  167.      * Adobe default is all sampling factors = 1,
  168.      * which is NOT the IJG default, so we must always assign values.
  169.      */
  170.     switch ((code = s_DCT_byte_params(plist, key, 0, num_colors,
  171.                       samples))
  172.     ) {
  173.     default:        /* error */
  174.         return code;
  175.     case 0:
  176.         break;
  177.     case 1:
  178.         samples[0] = samples[1] = samples[2] = samples[3] = 1;
  179.     }
  180.     for (i = 0; i < num_colors; i++) {
  181.     if (samples[i] < 1 || samples[i] > 4)
  182.         return_error(gs_error_rangecheck);
  183.     if (is_vert)
  184.         comp_info[i].v_samp_factor = samples[i];
  185.     else
  186.         comp_info[i].h_samp_factor = samples[i];
  187.     }
  188.     return 0;
  189. }
  190.  
  191. /* Main procedure */
  192. int
  193. s_DCTE_put_params(gs_param_list * plist, stream_DCT_state * pdct)
  194. {
  195.     jpeg_compress_data *jcdp = pdct->data.compress;
  196.     dcte_scalars_t params;
  197.     int i;
  198.     int code;
  199.  
  200.     params = dcte_scalars_default;
  201.     /*
  202.      * Required parameters for DCTEncode.
  203.      * (DCTDecode gets the equivalent info from the SOF marker.)
  204.      */
  205.     code = gs_param_read_items(plist, ¶ms, s_DCTE_param_items);
  206.     if (code < 0)
  207.     return code;
  208.     if (params.Columns <= 0 || params.Columns > 0xffff ||
  209.     params.Rows <= 0 || params.Rows > 0xffff ||
  210.     params.Colors <= 0 || params.Colors == 2 || params.Colors > 4 ||
  211.     params.Resync < 0 || params.Resync > 0xffff ||
  212.     params.Blend < 0 || params.Blend > 1
  213.     )
  214.     return_error(gs_error_rangecheck);
  215. /****** HACK: SET DEFAULTS HERE ******/
  216.     jcdp->Picky = 0;
  217.     jcdp->Relax = 0;
  218.     if ((code = s_DCT_put_params(plist, pdct)) < 0 ||
  219.     (code = s_DCT_put_huffman_tables(plist, pdct, false)) < 0
  220.     )
  221.     return code;
  222.     switch ((code = s_DCT_put_quantization_tables(plist, pdct, false))) {
  223.     case 0:
  224.         break;
  225.     default:
  226.         return code;
  227.     case 1:
  228.         /* No QuantTables, but maybe a QFactor to apply to default. */
  229.         if (pdct->QFactor != 1.0) {
  230.         code = gs_jpeg_set_linear_quality(pdct,
  231.                          (int)(min(pdct->QFactor, 100.0)
  232.                            * 100.0 + 0.5),
  233.                           TRUE);
  234.         if (code < 0)
  235.             return code;
  236.         }
  237.     }
  238.     /* Set up minimal image description & call set_defaults */
  239.     jcdp->cinfo.image_width = params.Columns;
  240.     jcdp->cinfo.image_height = params.Rows;
  241.     jcdp->cinfo.input_components = params.Colors;
  242.     switch (params.Colors) {
  243.     case 1:
  244.         jcdp->cinfo.in_color_space = JCS_GRAYSCALE;
  245.         break;
  246.     case 3:
  247.         jcdp->cinfo.in_color_space = JCS_RGB;
  248.         break;
  249.     case 4:
  250.         jcdp->cinfo.in_color_space = JCS_CMYK;
  251.         break;
  252.     default:
  253.         jcdp->cinfo.in_color_space = JCS_UNKNOWN;
  254.     }
  255.     if ((code = gs_jpeg_set_defaults(pdct)) < 0)
  256.     return code;
  257.     /* Change IJG colorspace defaults as needed;
  258.      * set ColorTransform to what will go in the Adobe marker.
  259.      */
  260.     switch (params.Colors) {
  261.     case 3:
  262.         if (pdct->ColorTransform < 0)
  263.         pdct->ColorTransform = 1;    /* default */
  264.         if (pdct->ColorTransform == 0) {
  265.         if ((code = gs_jpeg_set_colorspace(pdct, JCS_RGB)) < 0)
  266.             return code;
  267.         } else
  268.         pdct->ColorTransform = 1;    /* flag YCC xform */
  269.         break;
  270.     case 4:
  271.         if (pdct->ColorTransform < 0)
  272.         pdct->ColorTransform = 0;    /* default */
  273.         if (pdct->ColorTransform != 0) {
  274.         if ((code = gs_jpeg_set_colorspace(pdct, JCS_YCCK)) < 0)
  275.             return code;
  276.         pdct->ColorTransform = 2;    /* flag YCCK xform */
  277.         } else {
  278.         if ((code = gs_jpeg_set_colorspace(pdct, JCS_CMYK)) < 0)
  279.             return code;
  280.         }
  281.         break;
  282.     default:
  283.         pdct->ColorTransform = 0;    /* no transform otherwise */
  284.         break;
  285.     }
  286.     /* Optional encoding-only parameters */
  287.     pdct->Markers.data = params.Markers.data;
  288.     pdct->Markers.size = params.Markers.size;
  289.     pdct->NoMarker = params.NoMarker;
  290.     if ((code = dcte_put_samples(plist, "HSamples", params.Colors,
  291.                  jcdp, false)) < 0 ||
  292.     (code = dcte_put_samples(plist, "VSamples", params.Colors,
  293.                  jcdp, true)) < 0
  294.     )
  295.     return code;
  296.     jcdp->cinfo.write_JFIF_header = FALSE;
  297.     jcdp->cinfo.write_Adobe_marker = FALSE;    /* must do it myself */
  298.     jcdp->cinfo.restart_interval = params.Resync;
  299.     /* What to do with Blend ??? */
  300.     if (pdct->data.common->Relax == 0) {
  301.     jpeg_component_info *comp_info = jcdp->cinfo.comp_info;
  302.     int num_samples;
  303.  
  304.     for (i = 0, num_samples = 0; i < params.Colors; i++)
  305.         num_samples += comp_info[i].h_samp_factor *
  306.         comp_info[i].v_samp_factor;
  307.     if (num_samples > 10)
  308.         return_error(gs_error_rangecheck);
  309.     /*
  310.      * Note: by default the IJG software does not allow
  311.      * num_samples to exceed 10, Relax or no.  For full
  312.      * compatibility with Adobe's non-JPEG-compliant
  313.      * software, set MAX_BLOCKS_IN_MCU to 64 in jpeglib.h.
  314.      */
  315.     }
  316.     return 0;
  317. }
  318.